3.3 Datenfelder (Arrays)  
3.3.1 Eindimensionale Arrays 
Arrays, auch als Felder bezeichnet, ermöglichen eine nahezu beliebig große Anzahl Variablen gleichen Namens und gleichen Datentyps zu definieren. Unterschieden werden die einzelnen Elemente nur anhand einer Indizierung. Arrays – häufig auch als Felder bezeichnet – kommen insbesondere dann zum Einsatz, wenn in Programmschleifen auf alle oder einen Teil der Elemente dieselben Operationen ausgeführt werden sollen. Im Gegensatz zu früheren Versionen von Visual Basic kann man nicht mehr eindeutig zwischen statischen und dynamischen Arrays unterscheiden, weil die Größe eines Arrays grundsätzlich immer anforderungsgerecht angepasst werden kann.
Die Deklaration eines Feldes wird am besten an einem Beispiel verdeutlicht:
| Dim element(10) As Integer
|
Das Array lautet auf den Namen element. Die Deklaration im Allgemeinteil eines Moduls kann sowohl Public als auch Private (bzw. Dim) sein. Innerhalb einer Prozedur sind nur die Modifizierer Dim und Static zugelassen, und das Array hat dann nur einen lokal auf die Prozedur beschränkten Sichtbarkeitsbereich. Sie können daraus entnehmen, dass für Felder hinsichtlich der Sichtbarkeit und Lebensdauer dieselben Regeln gelten wie bei den Variablen.
|
Hinter dem Bezeichner einer Array-Deklaration ist der Index des letzten Array-Elements angegeben. Der Index des ersten Elements, die Untergrenze, ist grundsätzlich immer 0.
|
Indizes sind ganzzahlig und werden kontinuierlich vergeben. Somit stellt das Feld element des obigen Beispiels die Elemente
| element(0), element(1) ... element(10)
|
bereit. Die Anzahl der Elemente ergibt sich damit zu:
| Anzahl der Arrayelemente = letzter Index + 1
|
Ein bestimmtes Element aus diesem Feld wird mit dem Array-Namen unter Angabe seines Indizes angesprochen, beispielsweise mit:
Wie eingangs erwähnt, kommen Arrays in der Praxis besonders häufig zum Einsatz, wenn die Inhalte der Elemente miteinander in Beziehung stehen, beispielsweise weil sie auf derselben mathematischen Grundlage basieren. Um die Elemente solcher Felder mit Werten zu initialisieren, bietet es sich an, alle Indizes in einer Schleife zu durchlaufen. Im folgenden Codefragment wird jedem Element das Quadrat seines Index zugewiesen.
| Module Module1
|
| Sub Main()
|
| Dim element(10) As Integer, counter As Integer
|
| For counter = 0 To 10
|
| element(counter) = CInt(counter ^ 2)
|
| Console.WriteLine("{0}.Element = {1}", i, element(counter))
|
| Next
|
| Console.Read()
|
| End Sub
|
| End Module
|
Die For-Next-Schleife, mit der wir uns in Abschnitt 3.6.1 noch genau beschäftigen werden, wird vom Startwert
bis zum Endwert
durchlaufen. Bei jedem Durchlauf wird der Zähler um +1 erhöht, hat also im zweiten Durchlauf den Wert 1, im dritten Durchlauf 2 usw. Innerhalb der Schleife wird der Inhalt der Zählervariablen counter dazu benutzt, um bei jedem Durchlauf den Index neu festzulegen. Das Quadrat des Zählers wird dem so referenzierten Array-Element zugewiesen. Das Ergebnis der Operation ist vom Typ Double und muss noch in einen Integer konvertiert werden.
| Anmerkung
|
|
Alternativ können Sie auch die arraykennzeichnenden runden Klammern hinter dem Datentyp angeben, also z. B.:
Dim element As Integer()
Allerdings darf dabei nicht die Feldgröße in den Klammern stehen.
|
Speicherabbild eines Arrays
Die Common Language Runtime betrachtet jedes Array als ein Objekt. Damit gelten Arrays als Referenztypen, und es ist klar, dass die interne Verwaltung eine andere sein muss als die der nativen Datentypen, die als Wertetypen behandelt werden. Wir wollen an dieser Stelle noch nicht auf die Möglichkeiten eingehen, die sich als Konsequenz daraus für Felder ergeben, denn das wird später noch ein Thema dieses Buches sein. Wir wollen uns vielmehr ein (deutlich) vereinfachtes Konstrukt ansehen, um zu verstehen, wie Arrays im Speicher verwaltet werden. Dabei ist es hilfreich, sich Felder als native Datentypen vorzustellen.
Ein Array beschreibt eine bestimmte Anzahl typgleicher Elemente, die im Speicher kettenartig hintereinander aufgereiht sind. Angenommen es sei das Array arr vom Typ Integer deklariert (der Typ spielt bei unserer mehr theoretisch ausgerichteten Betrachtung keine entscheidende Rolle) und den einzelnen Feldelementen seien Werte zugewiesen:
| Dim arr(6) As Integer
|
| arr(0) = 72 : arr(1) = 23 : arr(2) = 24
|
| arr(3) = 88 : arr(4) = 10 : arr(5) = 10 : arr(6) = 45
|
Nehmen wir rein hypothetisch an, das erste Element (arr(0)) würde die Speicheradresse 4000 für sich reservieren, könnte sich das Abbild des von uns betrachteten Speicherbereichs wie in der folgenden Abbildung 3.6 dargestellt präsentieren.
Mit der Zuweisung eines Datums an ein Element des Arrays bzw. dem Auswerten des Inhalts erfolgt ein direkter Zugriff auf die Adresse des entsprechenden Elements.
Interessant wird es, wenn Sie das Array einer zweiten Array-Variablen zuweisen wollen. Damit ist nicht die Schaffung einer Kopie (Clone) zu verstehen, sondern der Zugriff auf die Daten des ursprünglichen Arrays unter einem anderen Bezeichner.
| ' ---------------------------------------------------------------
|
| ' Beispiel: ...\Kapitel 3\ArrayAdresse
|
| ' ---------------------------------------------------------------
|
| Module Module1
|
| Sub Main()
|
| Dim arr(6) As Integer
|
| arr(0) = 72 : arr(1) = 23 : arr(2) = 24
|
| arr(3) = 88 : arr(4) = 10 : arr(5) = 10 : arr(6) = 45
|
| Dim secondArr() As Integer
|
| secondArr = arr
|
| arr(6) = 4711
|
| Dim i As Integer
|
| For i = 0 To 6
|
| Console.WriteLine("secondArr({0}) = {1}", i, secondArr(i))
|
| Next
|
| Console.ReadLine()
|
| End Sub
|
| End Module
|
Hier klicken, um das Bild zu Vergrößern
Abbildung 3.6 Speicherbereich eines Arrays
Zunächst wird das Array arr mit spezifischen Daten initialisiert, danach das Array secondArr deklariert. Bis hier ist noch nichts Ungewöhnliches zu bemerken, aber nun folgt die Anweisung:
Da die Laufzeitumgebung Arrays als Objekte behandelt, wird der Name eines Arrays ohne die zusätzliche Angabe eines Indizes der Startadresse des Arrays gleichgesetzt. Die Angabe arr steht somit für unsere fiktive Adresse 4000, die nun auch zur Startadresse des Arrays secondArr wird.
Der Beweis dieser Behauptung muss natürlich noch erbracht werden. In der Anweisung
wird das Datum des siebten Element des arr-Feldes verändert, danach werden in einer For-Next-Schleife alle Daten des Feldes secondArr an der Konsole angezeigt. Tatsächlich enthält das letzte Element dieses Arrays den Wert, der über arr(6) zugewiesen wurde. Damit haben wir den Beweis erbracht und können die folgende Regel festhalten:
|
Der Name eines Arrays ohne die Angabe eines Indizes verweist auf die Startadresse des Arrays.
|
3.3.2 Mehrdimensionale Arrays
Die bisher behandelten eindimensionalen Arrays können Sie sich als eine einfache Folge von Daten auf einer Geraden vorstellen. Zur Darstellung komplexer Datenstrukturen, beispielsweise räumlicher, sind eindimensionale Felder aber nicht besonders gut geeignet. Daher kommen in der Praxis auch häufig zwei oder noch höher dimensionierte Arrays zum Einsatz.
Ein zweidimensionales Array kann man sich so vorstellen, dass ein Array-Element selbst wieder ein Array definiert. Dabei müssen alle Elemente gleichen Typs sein. Denken Sie an eine Matrix oder eine Tabelle, um sich ein zweidimensionales Array anschaulich vorzustellen. Jede Zelle einer Tabelle ist eindeutig durch die Position in einer Reihe und einer Spalte identifizierbar.
Um den Inhalt einer Tabellenzelle durch ein bestimmtes Array-Element zu beschreiben, sollte ein zweidimensionales Feld definiert werden: Eine Dimension beschreibt die Reihe, die andere Dimension die Spalte. Angenommen, eine Tabelle hat vier Reihen und drei Spalten, so könnte die Deklaration
| Dim zelle(3, 2) As Integer
|
lauten (siehe auch Abbildung 3.11). In der ersten Dimension, welche die Reihen beschreibt, werden vier Elemente bereitgestellt, in der zweiten Dimension, die für die Spalte steht, drei. Damit enthält das Array insgesamt 4 * 3 = 12 Elemente, was auch der Anzahl der Zellen dieser Tabelle entspricht. Die Zuordnung, in der ersten Dimension die Zeilenanzahl und in der zweiten die Spaltenanzahl anzugeben, kann natürlich ebenso gut auch vertauscht werden.
Hier klicken, um das Bild zu Vergrößern
Abbildung 3.7 Visualisierung eines zweidimensionalen Arrays
Man kann auf eine bestimmte Zelle des Tabellenverbunds zugreifen, wenn sowohl die genaue Spalten- als auch die Zeilenposition bekannt ist. Die Wertzuweisung an die Zelle, die im Fadenkreuz der dritten Reihe der zweiten Spalte liegt, erfolgt mit:
3.3.3 Ändern der Array-Kapazität
Redimensionierung eindimensionaler Felder
Ist zur Entwicklungszeit nicht bekannt, wie groß die Kapazität eines Arrays zur Laufzeit sein muss, um alle erforderlichen Elemente aufzunehmen, kann die Angabe der Feldgröße unterbleiben.
Ein Array ohne Angabe der Feldgröße muss in jedem Fall zuerst redimensioniert werden, um den Array-Elementen Werte zuzuweisen. Redimensioniert wird mit dem Schlüsselwort ReDim unter Angabe des Feldnamens und der gewünschten Feldgröße.
Jetzt können den insgesamt 101 Elementen Integer-Werte zugewiesen werden. Stellt sich zu einem späteren Zeitpunkt eine unzureichende Größe heraus, darf auch wiederholt redimensioniert werden.
Interessant ist die Tatsache, dass ein Array jederzeit neu dimensioniert werden darf – selbst dann, wenn die Array-Kapazität bereits bei der Deklaration bekannt gegeben worden ist.
| Dim liste(5) As Integer
|
| ...
|
| ReDim liste(10)
|
Das Array liste ist als eindimensionales Feld deklariert. Daher kann auch nur die bekannte Dimension angepasst werden, und die folgende Anweisung zur Erweiterung eines ein- in ein zweidimensionales Feld wird zu einem Fehler führen:
| 'F E H L E R !
|
| ReDim liste(20, 50)
|
Redimensionierung mehrdimensionaler Felder
Um sich die Möglichkeit zu schaffen, ein mehrdimensionales Array zu redimensionieren, muss die Anzahl der Dimensionen schon aus der Deklaration hervorgehen:
| Dim MultipleDim(2, 2, 2) As Integer
|
| Redim MultipleDim(2, 12, 4)
|
Wenn die Anzahl der Dimensionen, jedoch die dimensionsabhängige Feldgröße unbekannt ist, können Sie sogar ein Feld nur durch die leere Angabe der Dimensionen deklarieren und zu einem späteren Zeitpunkt die endgültige Größe festlegen:
| Dim MultipleDim(, , ) As Integer
|
| Redim MultipleDim(10, 20, 24)
|
Die Redimensionierung und ihre Folgen
Bei aller Freude darüber, ein Array an die sich zur Laufzeit einstellenden Anforderungen uneingeschränkt dynamisch anpassen zu können, eine Einschränkung ist mit der Redimensionierung dennoch verbunden. Das soll im folgenden Codefragment zum Ausdruck gebracht werden.
| Dim liste(10) As Integer
|
| liste(5) = 410
|
| ReDim liste(20)
|
| Console.WriteLine(liste(5))
|
Einem Element des Arrays liste mit definierter Feldgröße wird ein Wert zugewiesen und anschließend die Kapazität des Arrays erhöht. Erstaunlich ist die Ausgabe an der Konsole. Sie lautet nicht – wie vielleicht zu vermuten wäre – für das sechste Element des Feldes 410, sondern es wird 0 angezeigt. Anscheinend verlieren bei einer Redimensionierung alle Feldelemente ihren Inhalt. Dies ist natürlich ein unerwünschter Nebeneffekt, der vermieden werden muss.
Um dem Problem zu begegnen, könnte der Inhalt des zu vergrößernden Arrays zunächst in ein zweites Feld kopiert, danach das Ausgangsarray redimensioniert und abschließend könnten die ursprünglichen Inhalte wieder zurückkopiert werden. Diese Lösung geht aber bei größeren Feldern mit Sicherheit zu Lasten der Performance und ist, falls nicht andere Gründe für genau diesen Weg sprechen, grundsätzlich abzulehnen.
Um die Werte bei der Redimensionierung beizubehalten, bietet VB 2005 eine syntaktische Lösung an: die Ergänzung der ReDim-Anweisung um das Schlüsselwort Preserve.
| Dim liste(10) As Integer
|
| liste(5) = 410
|
| ReDim Preserve liste(20)
|
| Console.WriteLine(liste(5))
|
Nun wird das Array vergrößert, und die Inhalte aller Elemente bleiben erhalten. Das gilt übrigens auch dann, wenn die Kapazität eines Arrays verkleinert wird – aber natürlich nur für die Elemente, die auch nach der Reduzierung der Feldgröße weiterhin einen gültigen Index aufweisen.
Im Zusammenhang mit mehrdimensionalen Arrays muss mit Preserve eine Einschränkung in Kauf genommen werden: Wird der Befehl Preserve auf ein mehrdimensionales Feld eingesetzt, kann nur die letzte Dimension verändert werden. Die alten Feldinhalte gehen dabei natürlich nicht verloren.
3.3.4 Initialisierung der Array-Elemente
Ein größeres Array zu initialisieren, kann zu einer sehr arbeitsintensiven und fehlerträchtigen Aufgabe werden:
| Dim intListe(20) As Long
|
| intListe(0) = 2
|
| intListe(1) = 56
|
| intListe(2) = 690
|
| ...
|
| intListe(19) = 25
|
Sie wissen, dass bei der Deklaration einer Variablen die Wertzuweisung schon in der Deklarationszeile erfolgen darf. Dies ist auch bei Arrays möglich, wie das folgende Beispiel demon- striert:
| Dim meinFeld() As Long = {23, 30, 100, 39}
|
Voraussetzung für diese Variante der Initialisierung ist die implizite Dimensionierung, bei der die Größe der Dimension nicht angegeben werden darf. Im Beispiel wird ein Array mit vier Elementen erzeugt. Dabei wird dem ersten Feldelement (Index = 0) das erste in den geschweiften Klammern stehende Literal zugewiesen, dem zweiten Feldelement (Index = 1) das zweite Literal usw. Die Felder sind demnach wie folgt initialisiert:
| meinFeld(0) = 23
|
| meinFeld(1) = 30
|
| meinFeld(2) = 100
|
| meinFeld(3) = 39
|
Sehr ähnlich wie eindimensionale Arrays, jedoch etwas komplizierter lassen sich auch mehrdimensionale bei ihrer Deklaration initialisieren:
| Dim A(,) As Integer = {{1, 2}, {3, 4}, {5, 6}}
|
Die Anzahl der inneren geschweiften Klammern – hier drei – entspricht der Anzahl der Elemente in der ersten Dimension, die Anzahl der Literale in den inneren geschweiften Klammern der Anzahl der Elemente in der zweiten Dimension – hier zwei. Diese Definition entspricht der eines Arrays A(2, 1):
| A(0, 0) = 1
|
| A(0, 1) = 2
|
| A(1, 0) = 3
|
| A(1, 1) = 4
|
| A(2, 0) = 5
|
| A(2, 1) = 6
|
Etwas schwieriger wird es, mit dieser Syntaxvariante Feldelemente zu initialisieren, wenn noch mehr Dimensionen eine Rolle spielen. Jede Dimensionsebene wird durch ein Paar geschweifter Klammern dargestellt, bei einem eindimensionalen Array also – wie oben eingangs gezeigt – durch ein Klammerpaar:
{Anzahl der Elemente der ersten Dimension}
Da ein zweidimensionales Array als ein Feld zu verstehen ist, bei dem jedes Array-Element selbst wieder ein eigenes Feld gleichen Typs definiert, wird jedes Element der Initialisierung eines eindimensionalen Arrays durch ein Paar geschweifter Klammern ersetzt, in dem wiederum Werte des »Unterarrays« angegeben werden:
{{Anzahl der Elemente der zweiten Dimension}, { }, ...}
Diese Systematik setzt sich mit jeder weiteren Dimension fort. Beispielhaft sei das noch an einem dreidimensionalen Array gezeigt:
{{{Anzahl der Elemente der dritten Dimension}, { }, ...}, { }, ...}
Das folgende Codebeispiel zeigt anhand eines dreidimensionalen Arrays, dass die Initialisierung mit zunehmender Dimensionstiefe immer komplizierter wird.
| Dim A(,,) As Integer = {{{1, 2, 3, 4}, _
|
| {3, 4, 5, 6}, _
|
| {6, 7, 8, 9}}, _
|
| {{3, 4, 6, 1}, _
|
| {6, 9, 3, 4}, _
|
| {4, 1, 8, 7}}}
|
Das Array entspricht dem eines mit A(1, 2, 3) definierten.
3.3.5 Bestimmung der Array-Obergrenze
Ein Problem tritt bei Arrays häufig auf, wenn zur Laufzeit die Kapazität eines bereits vorher redimensionierten Feldes ein zweites Mal um eine exakte Größe angehoben werden soll. Dazu ein kurzes Beispiel. Mit
| Dim liste(,) As Integer
|
| ...
|
| ReDim liste(Kap1, Kap2)
|
wird im Programmcode ein leeres Feld deklariert und die Größe zu einem späteren Zeitpunkt um den Inhalt der Variablen Kap1 und Kap2 dynamisch angepasst. Im weiteren Verlauf soll die Feldgröße noch einmal um genau zehn Elemente in der ersten und um acht Elemente in der zweiten Dimension angehoben werden. Um diese Forderung erfüllen zu können, muss die aktuelle Obergrenze des Feldes bekannt sein. VB 2005 bietet zu deren Bestimmung die Funktion UBound an, deren Rückgabewert der letzte verfügbare Index ist.
| UBound(<Arrayname> [,<Dimension>])
|
Im ersten Argument wird der Name des Arrays angegeben, im zweiten optional die Dimension. Fehlt die Angabe der Dimension, bezieht sich der Rückgabewert in jedem Fall auf die der ersten. Geben Sie die Dimensionen an, gilt die Zahl 1 für die erste, die Zahl 2 für die zweite Dimension usw.
Damit ist das Problem der Redimensionierung eines Arrays mit unbekannten Obergrenzen gelöst. Mit
| Dim liste(,) As Integer
|
| ReDim liste(Kap1, Kap2)
|
| ReDim liste(UBound(liste, 1) + 10, UBound(liste, 2) + 8)
|
wird die Größe des Arrays liste anforderungsgemäß in der ersten Dimension um zehn Elemente, in der zweiten Dimension um acht Elemente vergrößert.
3.3.6 Zusammenfassung
 |
Datenfelder (Arrays) beschreiben eine Menge gleichnamiger, typengleicher Variablen, die durch einen Index identifiziert werden. Die Common Language Runtime betrachtet ein Array als Referenztyp, es ist somit ein Objekt. |
| |
Der Index des ersten Elements eines Arrays ist immer 0, der des letzten Elements entspricht der Angabe in der Deklaration. |
| |
Der einfache Array-Name ohne die Angabe eines Indizes repräsentiert die Startadresse des Speicherbereichs, den das Feld für sich beansprucht. |
| |
Grundsätzlich kann die Kapazität jedes Arrays mit der Anweisung ReDim verändert werden. Dabei gehen alte Feldinhalte verloren. Zur Sicherstellung der Beibehaltung alter Feldinhalte muss die Redimensionierung mit ReDim Preserve erfolgen. |
| |
Mehrdimensionale Arrays können unter Bewahrung ihres Inhalts nur in der letzten Dimension redimensioniert werden. |
| |
Eine Redimensionierung zwecks Erhöhung der Anzahl der Dimensionen ist nicht möglich. |
| |
Arrays können wie Variablen bei der Deklaration initialisiert werden. Dazu werden die Startwerte in geschweiften Klammern geschrieben. Die Dimensionsgröße darf dabei nicht angegeben werden, sie erfolgt implizit. |
| |
Zur Bestimmung der Obergrenze eines Feldes liefert die Funktion UBound als Ergebnis des Aufrufs den Index des letzten Feldelements. |
|
